Tensorflow逐步实现记忆网络(Memory networks)第一部分

def _create_placeholders(self):
    # http://mlln.cn
    # 学习率
    self._lr = tf.placeholder(tf.float32, [], name="learning_rate")
    # 记忆
    # _memory_size: 记忆条数, 也可以理解为记忆中包括多少篇文章
    # _sentence_size: 句子长度, 也可以是文章长度
    # 这个矩阵的元素就是单词的索引值
    self._stories = tf.placeholder(tf.int32, [None, self._memory_size, self._sentence_size], name="stories")
    # 问题向量, 向量内元素代表单词的索引值
    self._queries = tf.placeholder(tf.int32, [None, self._sentence_size], name="queries")
    # 答案, 因为本文章设定问题的答案就是一个单词, 所以使用one-hot的方法编码答案
    self._answers = tf.placeholder(tf.int32, [None, self._vocab_size], name="answers")
    # 无意义的词向量, 代表为被词典收录的词
    nil_word = tf.zeros([1, self._embedding_size])
    # 
    A_placeholder = tf.concat(axis=0, values=
        [nil_word, self._normal_init([self._vocab_size-1, self._embedding_size])])
    
    C_placeholder = tf.concat(axis=0, values=
        [nil_word, self._normal_init([self._vocab_size-1, self._embedding_size])])
    
    with tf.variable_scope("memn2n"):
        # 我们将其命名为A_1，因为代码保持与论文所说的符号相关，如果你想理解权重的影响，你可以制作更多的A_k类型矩阵。
        # 我们遵循论文中描述的相邻权重共享，连续的A矩阵等于先前的C矩阵。        
        self.A_1 = tf.Variable(A_placeholder, name="A")
        # 现在我们添加了hop的概念，可以以相同的方式添加更多A类型矩阵。
        self.C = []
        # 这里我们将矩阵添加到每一hop对应于C矩阵的数组中。存储器中的hop数由n_hops表示。
        for hop_number in range(self._hops):
            # 每一hop都有自己的范围。
            with tf.variable_scope("hop_number{}".format(hop_number)):
                self.C.append(tf.Variable(C_placeholder, name="C"))     

def position_encoder(embedding_size, sentence_size):
    encoding = np.ones((embedding_size, sentence_size), dtype=np.float32)
    # 1 based indexing
    for k in range(1, embedding_size+1):
        for j in range(1, sentence_size+1):
            encoding[k-1, j-1] = (1 - j/sentence_size) - (k/embedding_size) * (1 - 2 * j/sentence_size)
    # make last word immune to encoding
    encoding[:, -1] = 1.0
    return np.transpose(encoding)

def _inference(self):
    with tf.variable_scope("memn2n"):
        # adjacent weight, B = A_1
        # 提示, self._queries 代表 问题向量, 向量内元素代表单词的索引值
        # 词的索引无法直接进入模型计算, 需要映射成词向量, 所以矩阵B就是保存了词向量的矩阵
        B = tf.nn.embedding_lookup(self.A_1, self._queries)
        # 求句子向量, 使用了位置编码算法
        u_1 = tf.reduce_sum(B * self._encoding, 1)
        # 请记住, u中存放的都是问题向量
        u = [u_1]

for hop_number in range(self._hops):
    if hop_number == 0:
        # first hop, C_1 = A_1
        # 转换为词向量
        A_lookup = tf.nn.embedding_lookup(self.A_1, self._stories)
        # 转换为文章向量 m_i
        m_A = tf.reduce_sum(A_lookup * self._encoding, 1)
    else:
        # 这是相邻的权重共享，除了第一个hop, 我们将m_A定义为上一个hop的m_C
        with tf.variable_scope("hop_number{}".format(hop_number-1)):
            # A_k+1 = C_k --> C[-1], topmost C
            # 转换为词向量
            A_lookup = tf.nn.embedding_lookup(self.C[hop_number-1], self._stories)
            # 转换为文章向量 m_i
            m_A = tf.reduce_sum(A_lookup * self._encoding, 1)
    # 根据 公式1 计算概率
    u_temp = tf.transpose(tf.expand_dims(u[-1], -1), [0, 2, 1])
    dot = tf.reduce_sum(m_A * u_temp, 2)
    print(dot.get_shape())
    prob = tf.nn.softmax(dot)
    P = tf.transpose(tf.expand_dims(prob, -1), [0, 2, 1])
    with tf.variable_scope("hop_number{}".format(hop_number)):
        C_lookup = tf.nn.embedding_lookup(self.C[hop_number], self._stories)
        m_C = tf.reduce_sum(C_lookup * self._encoding, 1)

m_C_temp = tf.transpose(m_C, [0, 2, 1])
o_k = tf.reduce_sum(m_C_temp * P, 2)
# 更新u
u_k = u[-1] + o_k
# 追加到列表中, 以备后用
u.append(u_k)

# W = last C, weight tying
with tf.variable_scope("hop_number{}".format(hop_number)):
    self._logits = tf.matmul(u_k, tf.transpose(self.C[-1], [1,0]))
    self._scores = tf.nn.softmax(self._logits)